home *** CD-ROM | disk | FTP | other *** search
/ Software of the Month Club 2000 October / Software of the Month - Ultimate Collection Shareware 277.iso / pc / PROGRAMS / UTILITY / WINLINUX / DATA1.CAB / programs_-_usrdoc / SVGALIB-.{2E / LRMI-0.5M / VBETEST.C < prev   
C/C++ Source or Header  |  1999-09-17  |  6KB  |  334 lines
  1. /*
  2. List the available VESA graphics and text modes.
  3.  
  4. This program is in the public domain.
  5. */
  6.  
  7. #include <stdio.h>
  8. #include <string.h>
  9. #include <unistd.h>
  10. #include <sys/ioctl.h>
  11. #include <sys/kd.h>
  12. #include <sys/stat.h>
  13.  
  14. #include "lrmi.h"
  15. #include "vbe.h"
  16.  
  17. struct
  18.     {
  19.     struct vbe_info_block *info;
  20.     struct vbe_mode_info_block *mode;
  21.     } vbe;
  22.  
  23. void *
  24. save_state(void)
  25.     {
  26.     struct LRMI_regs r;
  27.     void *buffer;
  28.  
  29.     memset(&r, 0, sizeof(r));
  30.  
  31.     r.eax = 0x4f04;
  32.     r.ecx = 0xf;     /* all states */
  33.     r.edx = 0;     /* get buffer size */
  34.  
  35.     if (!LRMI_int(0x10, &r))
  36.         {
  37.         fprintf(stderr, "Can't get video state buffer size (vm86 failure)\n");
  38.         return NULL;
  39.         }
  40.  
  41.     if ((r.eax & 0xffff) != 0x4f)
  42.         {
  43.         fprintf(stderr, "Get video state buffer size failed\n");
  44.         return NULL;
  45.         }
  46.  
  47.     buffer = LRMI_alloc_real((r.ebx & 0xffff) * 64);
  48.  
  49.     if (buffer == NULL)
  50.         {
  51.         fprintf(stderr, "Can't allocate video state buffer\n");
  52.         return NULL;
  53.         }
  54.  
  55.     memset(&r, 0, sizeof(r));
  56.  
  57.     r.eax = 0x4f04;
  58.     r.ecx = 0xf;     /* all states */
  59.     r.edx = 1;     /* save state */
  60.     r.es = (unsigned int)buffer >> 4;
  61.     r.ebx = (unsigned int)buffer & 0xf;
  62.  
  63.     if (!LRMI_int(0x10, &r))
  64.         {
  65.         fprintf(stderr, "Can't save video state (vm86 failure)\n");
  66.         return NULL;
  67.         }
  68.  
  69.     if ((r.eax & 0xffff) != 0x4f)
  70.         {
  71.         fprintf(stderr, "Save video state failed\n");
  72.         return NULL;
  73.         }
  74.  
  75.     return buffer;
  76.     }
  77.  
  78. void
  79. restore_state(void *buffer)
  80.     {
  81.     struct LRMI_regs r;
  82.  
  83.     memset(&r, 0, sizeof(r));
  84.  
  85.     r.eax = 0x4f04;
  86.     r.ecx = 0xf;     /* all states */
  87.     r.edx = 2;     /* restore state */
  88.     r.es = (unsigned int)buffer >> 4;
  89.     r.ebx = (unsigned int)buffer & 0xf;
  90.  
  91.     if (!LRMI_int(0x10, &r))
  92.         {
  93.         fprintf(stderr, "Can't restore video state (vm86 failure)\n");
  94.         }
  95.     else if ((r.eax & 0xffff) != 0x4f)
  96.         {
  97.         fprintf(stderr, "Restore video state failed\n");
  98.         }
  99.  
  100.     LRMI_free_real(buffer);
  101.     }
  102.  
  103. void
  104. text_mode(void)
  105.     {
  106.     struct LRMI_regs r;
  107.  
  108.     memset(&r, 0, sizeof(r));
  109.  
  110.     r.eax = 3;
  111.  
  112.     if (!LRMI_int(0x10, &r))
  113.         {
  114.         fprintf(stderr, "Can't set text mode (vm86 failure)\n");
  115.         }
  116.     }
  117.  
  118. void
  119. set_mode(int n)
  120.     {
  121.     struct LRMI_regs r;
  122.  
  123.     memset(&r, 0, sizeof(r));
  124.  
  125.     r.eax = 0x4f02;
  126.     r.ebx = n;
  127.  
  128.     if (!LRMI_int(0x10, &r))
  129.         {
  130.         fprintf(stderr, "Can't set video mode (vm86 failure)\n");
  131.         }
  132.     else if ((r.eax & 0xffff) != 0x4f)
  133.         {
  134.         fprintf(stderr, "Set video mode failed\n");
  135.         }
  136.  
  137.     memset(&r, 0, sizeof(r));
  138.  
  139.     r.eax = 0x4f01;
  140.     r.ecx = n;
  141.     r.es = (unsigned int)vbe.mode >> 4;
  142.     r.edi = (unsigned int)vbe.mode & 0xf;
  143.  
  144.     if (!LRMI_int(0x10, &r))
  145.         {
  146.         fprintf(stderr, "Can't get mode info (vm86 failure)\n");
  147.         return;
  148.         }
  149.  
  150.     if ((r.eax & 0xffff) != 0x4f)
  151.         {
  152.         fprintf(stderr, "Get mode info failed\n");
  153.         return;
  154.         }
  155.  
  156.     /*
  157.      Draw a blue/red fade on top line
  158.     */
  159.     if (vbe.mode->memory_model == VBE_MODEL_RGB)
  160.         {
  161.         char *p = (char *)(vbe.mode->win_a_segment << 4);
  162.         int pixel_size = (vbe.mode->bits_per_pixel + 7) / 8;
  163.         int x_res = vbe.mode->x_resolution;
  164.         int max_r = (1 << vbe.mode->red_mask_size) - 1;
  165.         int max_b = (1 << vbe.mode->blue_mask_size) - 1;
  166.         int shift_r = vbe.mode->red_field_position;
  167.         int shift_b = vbe.mode->blue_field_position;
  168.         int i;
  169.  
  170.         for (i = 0; i < x_res; i++)
  171.             {
  172.             int c;
  173.             c = (i * max_r / x_res) << shift_r;
  174.             c |= ((x_res - i) * max_b / x_res) << shift_b;
  175.  
  176.             memcpy(p + i * pixel_size, &c, pixel_size);
  177.             }
  178.         for (i=2048;i<0x7fff;i++)*(p+i)=(i&0xff);
  179.         for(i=0x8000;i<0xffff;i++)*(p+i)=85;
  180.         }
  181.     }
  182.  
  183. void
  184. interactive_set_mode(void)
  185.     {
  186.     int n;
  187.     void *state;
  188.     struct stat stat;
  189.  
  190.     if (fstat(0, &stat) != 0)
  191.         {
  192.         fprintf(stderr, "Can't stat() stdin\n");
  193.         return;
  194.         }
  195.  
  196.     if ((stat.st_rdev & 0xff00) != 0x400
  197.      || (stat.st_rdev & 0xff) > 63)
  198.         {
  199.         fprintf(stderr, "To switch video modes, "
  200.          "this program must be run from the console\n");
  201.         return;
  202.         }
  203.  
  204.     printf("mode? ");
  205.     scanf("%d", &n);
  206.  
  207.     printf("setting mode %d\n", n);
  208.  
  209.     ioctl(0, KDSETMODE, KD_GRAPHICS);
  210.  
  211.     state = save_state();
  212.  
  213.     if (state == NULL)
  214.         return;
  215.  
  216.     set_mode(n);
  217.  
  218.     sleep(5);
  219.  
  220.     text_mode();
  221.     restore_state(state);
  222.  
  223.     ioctl(0, KDSETMODE, KD_TEXT);
  224.     }
  225.  
  226. int
  227. main(void)
  228.     {
  229.     struct LRMI_regs r;
  230.     short int *mode_list;
  231.  
  232.     if (!LRMI_init())
  233.         return 1;
  234.  
  235.     vbe.info = LRMI_alloc_real(sizeof(struct vbe_info_block)
  236.      + sizeof(struct vbe_mode_info_block));
  237.  
  238.     if (vbe.info == NULL)
  239.         {
  240.         fprintf(stderr, "Can't alloc real mode memory\n");
  241.         return 1;
  242.         }
  243.  
  244.     vbe.mode = (struct vbe_mode_info_block *)(vbe.info + 1);
  245.  
  246.     /*
  247.      Allow read/write to all IO ports
  248.     */
  249.     ioperm(0, 0x400 , 1);
  250.     iopl(3);
  251.  
  252.     memset(&r, 0, sizeof(r));
  253.  
  254.     r.eax = 0x4f00;
  255.     r.es = (unsigned int)vbe.info >> 4;
  256.     r.edi = 0;
  257.  
  258.     memcpy(vbe.info->vbe_signature, "VBE2", 4);
  259.  
  260.     if (!LRMI_int(0x10, &r))
  261.         {
  262.         fprintf(stderr, "Can't get VESA info (vm86 failure)\n");
  263.         return 1;
  264.         }
  265.  
  266.     if ((r.eax & 0xffff) != 0x4f || strncmp(vbe.info->vbe_signature, "VESA", 4) != 0)
  267.         {
  268.         fprintf(stderr, "No VESA bios\n");
  269.         return 1;
  270.         }
  271.  
  272.     printf("VBE Version %x.%x\n",
  273.      (int)(vbe.info->vbe_version >> 8) & 0xff,
  274.      (int)vbe.info->vbe_version & 0xff);
  275.  
  276.     printf("%s\n",
  277.      (char *)(vbe.info->oem_string_seg * 16 + vbe.info->oem_string_off));
  278.  
  279.     mode_list = (short int *)(vbe.info->video_mode_list_seg * 16 + vbe.info->video_mode_list_off);
  280.  
  281.     while (*mode_list != -1)
  282.         {
  283.         memset(&r, 0, sizeof(r));
  284.  
  285.         r.eax = 0x4f01;
  286.         r.ecx = *mode_list;
  287.         r.es = (unsigned int)vbe.mode >> 4;
  288.         r.edi = (unsigned int)vbe.mode & 0xf;
  289.  
  290.         if (!LRMI_int(0x10, &r))
  291.             {
  292.             fprintf(stderr, "Can't get mode info (vm86 failure)\n");
  293.             return 1;
  294.             }
  295.  
  296.         if (vbe.mode->memory_model == VBE_MODEL_RGB)
  297.             printf("[%3d] %dx%d (%d:%d:%d)\n",
  298.              *mode_list,
  299.              vbe.mode->x_resolution,
  300.              vbe.mode->y_resolution,
  301.              vbe.mode->red_mask_size,
  302.              vbe.mode->green_mask_size,
  303.              vbe.mode->blue_mask_size);
  304.         else if (vbe.mode->memory_model == VBE_MODEL_256)
  305.             printf("[%3d] %dx%d (256 color palette)\n",
  306.              *mode_list,
  307.              vbe.mode->x_resolution,
  308.              vbe.mode->y_resolution);
  309.         else if (vbe.mode->memory_model == VBE_MODEL_PACKED)
  310.             printf("[%3d] %dx%d (%d color palette)\n",
  311.              *mode_list,
  312.              vbe.mode->x_resolution,
  313.              vbe.mode->y_resolution,
  314.              1 << vbe.mode->bits_per_pixel);
  315.         else if (vbe.mode->memory_model == VBE_MODEL_TEXT)
  316.             printf("[%3d] %dx%d (TEXT)\n",
  317.              *mode_list,
  318.              vbe.mode->x_resolution,
  319.              vbe.mode->y_resolution);
  320.                 else printf("[%3d] %dx%d (model=%d)\n",
  321.              *mode_list,
  322.              vbe.mode->x_resolution,
  323.              vbe.mode->y_resolution,
  324.                          vbe.mode->memory_model);
  325.         mode_list++;
  326.         }
  327.  
  328.     LRMI_free_real(vbe.info);
  329.  
  330.     interactive_set_mode();
  331.  
  332.     return 0;
  333.     }
  334.